﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using FBSAssist;
using IllusionUtility.GetUtility;
using UnityEngine;
using Utility;

// Token: 0x0200042C RID: 1068
public class GlobalMethod
{
	// Token: 0x06001A51 RID: 6737 RVA: 0x000E3DFC File Offset: 0x000E1FFC
	public static void setCameraMoveFlag(global::CameraControl_Ver2 _ctrl, bool _bPlay)
	{
		if (_ctrl == null)
		{
			return;
		}
		_ctrl.NoCtrlCondition = (() => !_bPlay);
	}

	// Token: 0x06001A52 RID: 6738 RVA: 0x000E3E38 File Offset: 0x000E2038
	public static bool IsCameraMoveFlag(global::CameraControl_Ver2 _ctrl)
	{
		if (_ctrl == null)
		{
			return false;
		}
		global::BaseCameraControl_Ver2.NoCtrlFunc noCtrlCondition = _ctrl.NoCtrlCondition;
		bool flag = true;
		if (noCtrlCondition != null)
		{
			flag = noCtrlCondition();
		}
		return !flag;
	}

	// Token: 0x06001A53 RID: 6739 RVA: 0x000E3E70 File Offset: 0x000E2070
	public static bool IsCameraActionFlag(global::CameraControl_Ver2 _ctrl)
	{
		return !(_ctrl == null) && _ctrl.isControlNow;
	}

	// Token: 0x06001A54 RID: 6740 RVA: 0x000E3E88 File Offset: 0x000E2088
	public static void setCameraBase(global::CameraControl_Ver2 _ctrl, Transform _transTarget)
	{
		if (_ctrl == null)
		{
			return;
		}
		_ctrl.transBase.localPosition = _transTarget.localPosition;
		_ctrl.transBase.localRotation = _transTarget.localRotation;
		_ctrl.transBase.position = _transTarget.position;
		_ctrl.transBase.rotation = _transTarget.rotation;
	}

	// Token: 0x06001A55 RID: 6741 RVA: 0x000E3EE8 File Offset: 0x000E20E8
	public static void CameraKeyCtrl(global::CameraControl_Ver2 _ctrl, global::CharFemale[] _Females)
	{
		if (_Females == null)
		{
			return;
		}
		if (_ctrl == null)
		{
			return;
		}
		if (!Input.GetKey(KeyCode.LeftControl) && !Input.GetKey(KeyCode.RightControl))
		{
			if (Input.GetKeyDown(KeyCode.Q))
			{
				GameObject gameObject = _Females[0].chaBody.objBone.transform.FindLoop("cf_J_Head");
				if (gameObject == null)
				{
					return;
				}
				_ctrl.TargetPos = _ctrl.transBase.InverseTransformPoint(gameObject.transform.position);
			}
			else if (Input.GetKeyDown(KeyCode.W))
			{
				GameObject gameObject2 = _Females[0].chaBody.objBone.transform.FindLoop("cf_J_Mune00");
				if (gameObject2 == null)
				{
					return;
				}
				_ctrl.TargetPos = _ctrl.transBase.InverseTransformPoint(gameObject2.transform.position);
			}
			else if (Input.GetKeyDown(KeyCode.E))
			{
				GameObject gameObject3 = _Females[0].chaBody.objBone.transform.FindLoop("cf_J_Kokan");
				if (gameObject3 == null)
				{
					return;
				}
				_ctrl.TargetPos = _ctrl.transBase.InverseTransformPoint(gameObject3.transform.position);
			}
		}
		else if (_Females[1].chaBody.objBone)
		{
			if (Input.GetKeyDown(KeyCode.Q))
			{
				GameObject gameObject4 = _Females[1].chaBody.objBone.transform.FindLoop("cf_J_Head");
				if (gameObject4 == null)
				{
					return;
				}
				_ctrl.TargetPos = _ctrl.transBase.InverseTransformPoint(gameObject4.transform.position);
			}
			else if (Input.GetKeyDown(KeyCode.W))
			{
				GameObject gameObject5 = _Females[1].chaBody.objBone.transform.FindLoop("cf_J_Mune00");
				if (gameObject5 == null)
				{
					return;
				}
				_ctrl.TargetPos = _ctrl.transBase.InverseTransformPoint(gameObject5.transform.position);
			}
			else if (Input.GetKeyDown(KeyCode.E))
			{
				GameObject gameObject6 = _Females[1].chaBody.objBone.transform.FindLoop("cf_J_Kokan");
				if (gameObject6 == null)
				{
					return;
				}
				_ctrl.TargetPos = _ctrl.transBase.InverseTransformPoint(gameObject6.transform.position);
			}
		}
	}

	// Token: 0x06001A56 RID: 6742 RVA: 0x000E414C File Offset: 0x000E234C
	public static void saveCamera(global::CameraControl_Ver2 _ctrl, string _strAssetPath, string _strfile)
	{
		if (_ctrl == null)
		{
			return;
		}
		_ctrl.CameraDataSave(_strAssetPath, _strfile);
	}

	// Token: 0x06001A57 RID: 6743 RVA: 0x000E4164 File Offset: 0x000E2364
	public static void loadCamera(global::CameraControl_Ver2 _ctrl, string _assetbundleFolder, string _strfile, bool _isDirect = false)
	{
		if (_ctrl == null)
		{
			return;
		}
		_ctrl.CameraDataLoad(_assetbundleFolder, _strfile, _isDirect);
	}

	// Token: 0x06001A58 RID: 6744 RVA: 0x000E4180 File Offset: 0x000E2380
	public static void loadResetCamera(global::CameraControl_Ver2 _ctrl, string _assetbundleFolder, string _strfile, bool _isDirect = false)
	{
		if (_ctrl == null)
		{
			return;
		}
		_ctrl.CameraResetDataLoad(_assetbundleFolder, _strfile, _isDirect);
	}

	// Token: 0x06001A59 RID: 6745 RVA: 0x000E419C File Offset: 0x000E239C
	public static void DebugLog(string _str, int _state = 0)
	{
	}

	// Token: 0x06001A5A RID: 6746 RVA: 0x000E41A0 File Offset: 0x000E23A0
	public static void SetAllClothState(global::CharFemale _female, bool _isUpper, int _state, bool _isForce = false)
	{
		if (_female == null)
		{
			return;
		}
		if (_state < 0)
		{
			_state = 0;
		}
		List<int> list = new List<int>();
		if (_isUpper)
		{
			list.Add(0);
			list.Add(2);
			list.Add(4);
			list.Add(6);
		}
		else
		{
			list.Add(1);
			list.Add(3);
			list.Add(5);
			list.Add(7);
			list.Add(9);
		}
		foreach (int num in list)
		{
			if (_female.chaClothes.IsStateKind(num) && ((int)_female.femaleStatusInfo.clothesState[num] < _state || _isForce))
			{
				_female.femaleClothes.SetClothesState(num, (byte)_state);
			}
		}
	}

	// Token: 0x06001A5B RID: 6747 RVA: 0x000E4290 File Offset: 0x000E2490
	public static int ValLoop(int valNow, int valMax)
	{
		return (valMax <= 1) ? 0 : ((valNow % valMax + valMax) % valMax);
	}

	// Token: 0x06001A5C RID: 6748 RVA: 0x000E42A8 File Offset: 0x000E24A8
	public static int ValLoopEX(int valNow, int valMin, int valMax)
	{
		return global::GlobalMethod.ValLoop(valNow - valMin, valMax - valMin) + valMin;
	}

	// Token: 0x06001A5D RID: 6749 RVA: 0x000E42B8 File Offset: 0x000E24B8
	public static void GetListString(string text, out string[,] data)
	{
		string[] array = text.Split(new char[]
		{
			'\n'
		});
		int num = array.Length;
		if (num != 0 && array[num - 1].Trim() == string.Empty)
		{
			num--;
		}
		int num2 = 0;
		for (int i = 0; i < num; i++)
		{
			string[] array2 = array[i].Split(new char[]
			{
				'\t'
			});
			num2 = Mathf.Max(num2, array2.Length);
		}
		data = new string[num, num2];
		for (int j = 0; j < num; j++)
		{
			string[] array3 = array[j].Split(new char[]
			{
				'\t'
			});
			for (int k = 0; k < array3.Length; k++)
			{
				array3[k] = array3[k].Replace("\r", string.Empty).Replace("\n", string.Empty);
				if (k >= num2)
				{
					break;
				}
				data[j, k] = array3[k];
			}
		}
	}

	// Token: 0x06001A5E RID: 6750 RVA: 0x000E43C8 File Offset: 0x000E25C8
	public static int GetIntTryParse(string _text, int _init = 0)
	{
		int result = 0;
		if (int.TryParse(_text, out result))
		{
			return result;
		}
		return _init;
	}

	// Token: 0x06001A5F RID: 6751 RVA: 0x000E43E8 File Offset: 0x000E25E8
	public static bool RangeOn<T>(T valNow, T valMin, T valMax) where T : IComparable
	{
		return valNow.CompareTo(valMax) <= 0 && valNow.CompareTo(valMin) >= 0;
	}

	// Token: 0x06001A60 RID: 6752 RVA: 0x000E4420 File Offset: 0x000E2620
	public static bool RangeOff<T>(T valNow, T valMin, T valMax) where T : IComparable
	{
		return valNow.CompareTo(valMax) < 0 && valNow.CompareTo(valMin) > 0;
	}

	// Token: 0x06001A61 RID: 6753 RVA: 0x000E4454 File Offset: 0x000E2654
	public static float lerpBeziereAppoint(Vector2 _vS, Vector2 _vE, Vector2 _vH, float _ft)
	{
		Vector2 vector;
		vector.x = (4f * _vH.x - _vS.x - _vE.x) / 4f;
		vector.y = (4f * _vH.y - _vS.y - _vE.y) / 4f;
		float num = 1f - _ft;
		float num2 = Mathf.Pow(num, 2f);
		float num3 = 2f * num * _ft;
		float num4 = Mathf.Pow(_ft, 2f);
		Vector2 vector2;
		vector2.x = num2 * _vS.x + num3 * vector.x + num4 * _vE.x;
		vector2.y = num2 * _vS.y + num3 * vector.y + num4 * _vE.y;
		return vector2.y;
	}

	// Token: 0x06001A62 RID: 6754 RVA: 0x000E4534 File Offset: 0x000E2734
	public static float lerpBeziere(float _fS, float _fE, Vector2 _vH, float _ft)
	{
		Vector2 vector;
		vector.x = (4f * _vH.x - 1f) / 4f;
		vector.y = (4f * _vH.y - _fS - _fE) / 4f;
		Vector2 vector2 = new Vector2(0f, _fS);
		Vector2 vector3 = new Vector2(1f, _fE);
		float num = 1f - _ft;
		float num2 = Mathf.Pow(num, 2f);
		float num3 = 2f * num * _ft;
		float num4 = Mathf.Pow(_ft, 2f);
		Vector2 vector4;
		vector4.x = num2 * vector2.x + num3 * vector.x + num4 * vector3.x;
		vector4.y = num2 * vector2.y + num3 * vector.y + num4 * vector3.y;
		return vector4.y;
	}

	// Token: 0x06001A63 RID: 6755 RVA: 0x000E4620 File Offset: 0x000E2820
	public static string LoadAllListText(string _assetbundleFolder, string _strLoadFile, List<string> _OmitFolderName = null)
	{
		StringBuilder stringBuilder = new StringBuilder();
		List<string> assetBundleNameListFromPath = global::CommonLib.GetAssetBundleNameListFromPath(_assetbundleFolder, false);
		assetBundleNameListFromPath.Sort();
		for (int i = 0; i < assetBundleNameListFromPath.Count; i++)
		{
			string text = Path.GetFileNameWithoutExtension(assetBundleNameListFromPath[i]);
			text = global::YS_Assist.GetStringRight(text, 2);
			if (_OmitFolderName == null || !_OmitFolderName.Contains(text))
			{
				string[] allAssetName = global::AssetBundleCheck.GetAllAssetName(assetBundleNameListFromPath[i], false);
				bool flag = false;
				for (int j = 0; j < allAssetName.Length; j++)
				{
					if (allAssetName[j].Compare(_strLoadFile, true))
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					global::GlobalMethod.DebugLog(string.Concat(new string[]
					{
						"[",
						assetBundleNameListFromPath[i],
						"][",
						_strLoadFile,
						"]は見つかりません"
					}), 1);
				}
				else
				{
					TextAsset textAsset = global::CommonLib.LoadAsset<TextAsset>(assetBundleNameListFromPath[i], _strLoadFile, false, string.Empty);
					global::AssetBundleManager.UnloadAssetBundle(assetBundleNameListFromPath[i], true, null);
					if (!(textAsset == null))
					{
						stringBuilder.Append(textAsset.text);
					}
				}
			}
		}
		return stringBuilder.ToString();
	}

	// Token: 0x06001A64 RID: 6756 RVA: 0x000E475C File Offset: 0x000E295C
	public static List<string> LoadAllListTextFromList(string _assetbundleFolder, string _strLoadFile, List<string> _OmitFolderName = null)
	{
		List<string> list = new List<string>();
		List<string> assetBundleNameListFromPath = global::CommonLib.GetAssetBundleNameListFromPath(_assetbundleFolder, false);
		assetBundleNameListFromPath.Sort();
		for (int i = 0; i < assetBundleNameListFromPath.Count; i++)
		{
			string text = Path.GetFileNameWithoutExtension(assetBundleNameListFromPath[i]);
			text = global::YS_Assist.GetStringRight(text, 2);
			if (_OmitFolderName == null || !_OmitFolderName.Contains(text))
			{
				string[] allAssetName = global::AssetBundleCheck.GetAllAssetName(assetBundleNameListFromPath[i], false);
				bool flag = false;
				for (int j = 0; j < allAssetName.Length; j++)
				{
					if (allAssetName[j].Compare(_strLoadFile, true))
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					global::GlobalMethod.DebugLog(string.Concat(new string[]
					{
						"[",
						assetBundleNameListFromPath[i],
						"][",
						_strLoadFile,
						"]は見つかりません"
					}), 1);
				}
				else
				{
					TextAsset textAsset = global::CommonLib.LoadAsset<TextAsset>(assetBundleNameListFromPath[i], _strLoadFile, false, string.Empty);
					global::AssetBundleManager.UnloadAssetBundle(assetBundleNameListFromPath[i], true, null);
					if (!(textAsset == null))
					{
						list.Add(textAsset.text);
					}
				}
			}
		}
		return list;
	}

	// Token: 0x06001A65 RID: 6757 RVA: 0x000E4890 File Offset: 0x000E2A90
	public static List<global::ExcelData.Param> LoadExcelData(string _strAssetPath, string _strFileName, int sCell, int sRow, int eCell, int eRow, bool _isWarning = true)
	{
		if (!global::AssetBundleCheck.IsFile(_strAssetPath, _strFileName))
		{
			if (_isWarning)
			{
				global::GlobalMethod.DebugLog(string.Concat(new string[]
				{
					"excel : [",
					_strAssetPath,
					"][",
					_strFileName,
					"]は見つかりません"
				}), 1);
			}
			return null;
		}
		global::AssetBundleLoadAssetOperation assetBundleLoadAssetOperation = global::AssetBundleManager.LoadAsset(_strAssetPath, _strFileName, typeof(global::ExcelData), null);
		global::AssetBundleManager.UnloadAssetBundle(_strAssetPath, true, null);
		if (assetBundleLoadAssetOperation.IsEmpty())
		{
			if (_isWarning)
			{
				global::GlobalMethod.DebugLog(string.Concat(new string[]
				{
					"excel : [",
					_strFileName,
					"]は[",
					_strAssetPath,
					"]の中に入っていません"
				}), 1);
			}
			return null;
		}
		global::ExcelData asset = assetBundleLoadAssetOperation.GetAsset<global::ExcelData>();
		List<string> cell = asset.GetCell(sCell);
		List<string> row = asset.GetRow(sRow);
		return asset.Get(new global::ExcelData.Specify(eCell, eRow), new global::ExcelData.Specify(cell.Count, row.Count));
	}

	// Token: 0x06001A66 RID: 6758 RVA: 0x000E497C File Offset: 0x000E2B7C
	public static List<global::ExcelData.Param> LoadExcelDataAlFindlFile(string _strAssetPath, string _strFileName, int sCell, int sRow, int eCell, int eRow, List<string> _OmitFolderName = null, bool _isWarning = true)
	{
		List<string> assetBundleNameListFromPath = global::CommonLib.GetAssetBundleNameListFromPath(_strAssetPath, false);
		assetBundleNameListFromPath.Sort();
		for (int i = 0; i < assetBundleNameListFromPath.Count; i++)
		{
			string text = Path.GetFileNameWithoutExtension(assetBundleNameListFromPath[i]);
			text = global::YS_Assist.GetStringRight(text, 2);
			if (_OmitFolderName == null || !_OmitFolderName.Contains(text))
			{
				string[] allAssetName = global::AssetBundleCheck.GetAllAssetName(assetBundleNameListFromPath[i], false);
				bool flag = false;
				for (int j = 0; j < allAssetName.Length; j++)
				{
					if (allAssetName[j].Compare(_strFileName, true))
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					global::GlobalMethod.DebugLog(string.Concat(new string[]
					{
						"[",
						assetBundleNameListFromPath[i],
						"][",
						_strFileName,
						"]は見つかりません"
					}), 1);
				}
				else
				{
					List<global::ExcelData.Param> list = global::GlobalMethod.LoadExcelData(assetBundleNameListFromPath[i], _strFileName, sCell, sRow, eCell, eRow, _isWarning);
					if (list != null)
					{
						return list;
					}
				}
			}
		}
		return null;
	}

	// Token: 0x06001A67 RID: 6759 RVA: 0x000E4A88 File Offset: 0x000E2C88
	public static T LoadAllFolderInOneFile<T>(string _findFolder, string _strLoadFile, List<string> _OmitFolderName = null) where T : UnityEngine.Object
	{
		List<string> assetBundleNameListFromPath = global::CommonLib.GetAssetBundleNameListFromPath(_findFolder, false);
		assetBundleNameListFromPath.Sort();
		for (int i = 0; i < assetBundleNameListFromPath.Count; i++)
		{
			string text = Path.GetFileNameWithoutExtension(assetBundleNameListFromPath[i]);
			text = global::YS_Assist.GetStringRight(text, 2);
			if (_OmitFolderName == null || !_OmitFolderName.Contains(text))
			{
				string[] allAssetName = global::AssetBundleCheck.GetAllAssetName(assetBundleNameListFromPath[i], false);
				bool flag = false;
				for (int j = 0; j < allAssetName.Length; j++)
				{
					if (allAssetName[j].Compare(_strLoadFile, true))
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					T result = global::CommonLib.LoadAsset<T>(assetBundleNameListFromPath[i], _strLoadFile, false, string.Empty);
					global::AssetBundleManager.UnloadAssetBundle(assetBundleNameListFromPath[i], true, null);
					return result;
				}
				global::GlobalMethod.DebugLog(string.Concat(new string[]
				{
					"[",
					assetBundleNameListFromPath[i],
					"][",
					_strLoadFile,
					"]は見つかりません"
				}), 1);
			}
		}
		return (T)((object)null);
	}

	// Token: 0x06001A68 RID: 6760 RVA: 0x000E4B9C File Offset: 0x000E2D9C
	public static List<T> LoadAllFolder<T>(string _findFolder, string _strLoadFile, List<string> _OmitFolderName = null) where T : UnityEngine.Object
	{
		List<T> list = new List<T>();
		List<string> assetBundleNameListFromPath = global::CommonLib.GetAssetBundleNameListFromPath(_findFolder, false);
		assetBundleNameListFromPath.Sort();
		for (int i = 0; i < assetBundleNameListFromPath.Count; i++)
		{
			string text = Path.GetFileNameWithoutExtension(assetBundleNameListFromPath[i]);
			text = global::YS_Assist.GetStringRight(text, 2);
			if (_OmitFolderName == null || !_OmitFolderName.Contains(text))
			{
				string[] allAssetName = global::AssetBundleCheck.GetAllAssetName(assetBundleNameListFromPath[i], false);
				bool flag = false;
				for (int j = 0; j < allAssetName.Length; j++)
				{
					if (allAssetName[j].Compare(_strLoadFile, true))
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					global::GlobalMethod.DebugLog(string.Concat(new string[]
					{
						"[",
						assetBundleNameListFromPath[i],
						"][",
						_strLoadFile,
						"]は見つかりません"
					}), 1);
				}
				else
				{
					T t = global::CommonLib.LoadAsset<T>(assetBundleNameListFromPath[i], _strLoadFile, false, string.Empty);
					global::AssetBundleManager.UnloadAssetBundle(assetBundleNameListFromPath[i], true, null);
					if (t)
					{
						list.Add(t);
					}
				}
			}
		}
		return list;
	}

	// Token: 0x06001A69 RID: 6761 RVA: 0x000E4CCC File Offset: 0x000E2ECC
	public static bool CheckFlagsArray(bool[] flags, int _check = 0)
	{
		if (flags.Length == 0)
		{
			return false;
		}
		bool flag = _check == 0;
		foreach (bool flag2 in flags)
		{
			if ((_check != 0) ? flag2 : (!flag2))
			{
				return !flag;
			}
		}
		return flag;
	}

	// Token: 0x0200042D RID: 1069
	public class RatioRand
	{
		// Token: 0x06001A6A RID: 6762 RVA: 0x000E4D20 File Offset: 0x000E2F20
		public RatioRand()
		{
			this.allVal = 0f;
		}

		// Token: 0x06001A6B RID: 6763 RVA: 0x000E4D40 File Offset: 0x000E2F40
		public virtual bool Add(int no, float ratio)
		{
			if (ratio == 0f)
			{
				global::GlobalMethod.DebugLog("ランダム 追加登録個数が0", 0);
				return false;
			}
			if (this.checks.Exists((global::GlobalMethod.RatioRand.CCheck i) => i.no == no))
			{
				global::GlobalMethod.DebugLog("ランダム 重複登録", 0);
				return false;
			}
			global::GlobalMethod.RatioRand.CCheck ccheck = new global::GlobalMethod.RatioRand.CCheck();
			ccheck.no = no;
			ccheck.minVal = this.allVal;
			ccheck.maxVal = this.allVal + ratio;
			this.allVal += ratio;
			this.checks.Add(ccheck);
			return true;
		}

		// Token: 0x06001A6C RID: 6764 RVA: 0x000E4DE4 File Offset: 0x000E2FE4
		public virtual int Random()
		{
			if (this.IsEmpty())
			{
				return -999999;
			}
			float randVal = UnityEngine.Random.Range(0f, this.allVal);
			global::GlobalMethod.RatioRand.CCheck ccheck = this.checks.Find((global::GlobalMethod.RatioRand.CCheck x) => randVal >= x.minVal && randVal <= x.maxVal);
			if (ccheck == null)
			{
				return -999999;
			}
			return ccheck.no;
		}

		// Token: 0x06001A6D RID: 6765 RVA: 0x000E4E48 File Offset: 0x000E3048
		public virtual bool IsEmpty()
		{
			return this.checks.Count == 0;
		}

		// Token: 0x06001A6E RID: 6766 RVA: 0x000E4E58 File Offset: 0x000E3058
		public virtual void Clear()
		{
			this.allVal = 0f;
			this.checks.Clear();
		}

		// Token: 0x0400214A RID: 8522
		protected float allVal;

		// Token: 0x0400214B RID: 8523
		protected List<global::GlobalMethod.RatioRand.CCheck> checks = new List<global::GlobalMethod.RatioRand.CCheck>();

		// Token: 0x0200042E RID: 1070
		public enum RandError
		{
			// Token: 0x0400214D RID: 8525
			Error_None = -999999
		}

		// Token: 0x0200042F RID: 1071
		protected class CCheck
		{
			// Token: 0x0400214E RID: 8526
			public int no;

			// Token: 0x0400214F RID: 8527
			public float minVal;

			// Token: 0x04002150 RID: 8528
			public float maxVal;
		}
	}

	// Token: 0x02000432 RID: 1074
	public class FloatBlend
	{
		// Token: 0x06001A75 RID: 6773 RVA: 0x000E4ED8 File Offset: 0x000E30D8
		public virtual bool Start(float _min, float _max, float _timeBlend = 0.15f)
		{
			this.tpc.SetProgressTime(_timeBlend);
			this.tpc.Start();
			this.min = _min;
			this.max = _max;
			this.blend = true;
			return true;
		}

		// Token: 0x06001A76 RID: 6774 RVA: 0x000E4F08 File Offset: 0x000E3108
		public virtual bool Proc(ref float _ans)
		{
			if (!this.blend)
			{
				return false;
			}
			float num = this.tpc.Calculate();
			_ans = Mathf.Lerp(this.min, this.max, num);
			if (num >= 1f)
			{
				this.blend = false;
			}
			return true;
		}

		// Token: 0x04002153 RID: 8531
		protected bool blend;

		// Token: 0x04002154 RID: 8532
		protected float min;

		// Token: 0x04002155 RID: 8533
		protected float max;

		// Token: 0x04002156 RID: 8534
		protected FBSAssist.TimeProgressCtrl tpc = new FBSAssist.TimeProgressCtrl(0.15f);
	}
}
